home *** CD-ROM | disk | FTP | other *** search
/ Acorn User: China / Acorn User China CD-ROM (UK) (Disc B) / Acorn User China CD-ROM (UK) (Disc B).bin / BARNET / MANUALS / WWW / LIST.C next >
Encoding:
C/C++ Source or Header  |  1998-05-07  |  14.3 KB  |  534 lines
  1. /***************************************************************************/
  2. /*                                                                         */
  3. /*  Program : to create various index files in both txt and html format    */
  4. /*                                                                         */
  5. /*                                                                         */
  6. /*  Author  : C.Carpenter                                                  */
  7. /*  Date    : 18/04/98                                                     */
  8. /*                                                                         */
  9. /***************************************************************************/
  10.  
  11.  
  12.  
  13. /***************************************************************************/
  14. /*  includes                                                               */
  15. /***************************************************************************/
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19.  
  20.  
  21.  
  22. /***************************************************************************/
  23. /*  defines                                                                */
  24. /***************************************************************************/
  25. #define FALSE          0
  26. #define TRUE           1
  27. #define MAX_FILENAME   256
  28. #define MAX_EXCLUDES   50
  29. #define MAX_FILES      1000
  30.  
  31. /*#ifdef __riscos
  32. #define strcasecmp stricmp
  33. #endif
  34.  */
  35.  
  36.  
  37. /***************************************************************************/
  38. /*  global variables                                                       */
  39. /***************************************************************************/
  40. typedef struct 
  41. {  
  42.   char filename[MAX_FILENAME]; 
  43. } exclude_rec;
  44.  
  45. exclude_rec excludes[MAX_EXCLUDES];
  46. int total_excludes;
  47.  
  48. typedef struct
  49. {
  50.   char rights[11];
  51.   char val[2];
  52.   char user[10];
  53.   char group[10];
  54.   char size[10];
  55.   char dayword[4];
  56.   char month[4];
  57.   char daynum[3];
  58.   char hour[3];
  59.   char min[3];
  60.   char sec[3];
  61.   char year[5];
  62.   char filename[MAX_FILENAME];
  63.   char directory[MAX_FILENAME];
  64.   
  65. } rec;
  66.  
  67. rec record[MAX_FILES];
  68. int indx[MAX_FILES];
  69. int total_files;
  70.  
  71. char d[20];
  72.  
  73.  
  74.  
  75.  
  76. /***************************************************************************/
  77. /*  function names                                                         */
  78. /***************************************************************************/
  79. int readData(char *filename);
  80. int readExcludes(void);
  81. int checkExcludes(char *filename);
  82. int createAlphaList(char *fname);
  83. int createAuthorList(char *fname);
  84. int createLatestChanges(char *filename);
  85. int writeHTMLHeader(char *filename, char *title, char *header);
  86. int writeHTMLFooter(char *filename);
  87.  
  88.  
  89.  
  90.  
  91.  
  92. /***************************************************************************/
  93. /*  main                                                                   */
  94. /***************************************************************************/
  95. int main(int argc, char *argv[])
  96. {
  97.   
  98.   
  99.   /* Check for the right number of parameters */
  100.   if (argc!=3) 
  101.   {
  102.     printf("Usage: list <filein> <fileout>\n");
  103.     return(1); 
  104.   }   
  105.  
  106.   /* read in the excludes file */
  107.   if ((total_excludes = readExcludes()) <0)
  108.   {
  109.     printf("Unable to open excludes file\n");
  110.     return(1); 
  111.   }
  112.   
  113.   total_files = readData(argv[1]);
  114.   
  115.   if (total_files > 0)
  116.   {
  117.     createAlphaList(argv[2]);
  118.     createAuthorList(argv[2]);
  119. //    createLatestChanges(argv[2]);
  120.   }
  121.  
  122.   return(0);
  123. }
  124.  
  125.  
  126.   
  127.   
  128. /***************************************************************************/
  129. /*  readData                                                               */
  130. /***************************************************************************/  
  131. int readData(char *filename)
  132. {  
  133.   int count=0, k=0;
  134.   char directory[MAX_FILENAME]; 
  135.   FILE *handle; 
  136.   char buffer[256];
  137.   
  138.   
  139.   
  140.   /* Make sure we can open the in file */
  141.   if ((handle=fopen(filename, "r"))==NULL)
  142.   {
  143.     printf("Unable to open file '%s' for reading\n", filename);
  144.     exit(1); 
  145.   }
  146.  
  147.  
  148.   /* Read in the data from the ls -lR list into an array */
  149.   count = 0;
  150.   directory[0]='\0';
  151.   while (!feof(handle))
  152.   {
  153.     /* Read the next line */
  154.     fgets(buffer, sizeof(buffer), handle);
  155.     if ((strrchr(buffer, ':')!=NULL) && (strchr(buffer, ' ')==NULL))
  156.     {
  157.       strncpy(directory, buffer, 256);
  158.       directory[255]='\0';
  159.       directory[strlen(directory)-2]='\0'; // Get rid of the ':'
  160.     }
  161.     else
  162.     {
  163.       if (strlen(buffer)>1)
  164.       {
  165.         sscanf(buffer, "%10s %1d %8s %8s %9s %3s %3s %2s %2s:%2s:%2s %4s %s",
  166.                      record[count].rights,
  167.                      record[count].val,
  168.                      record[count].user,
  169.                      record[count].group,
  170.                      record[count].size,
  171.                      record[count].dayword,
  172.                      record[count].month,
  173.                      record[count].daynum,
  174.                      record[count].hour,
  175.                      record[count].min,
  176.                      record[count].sec,
  177.                      record[count].year,
  178.                      record[count].filename );
  179.      
  180.         strcpy(record[count].directory, directory);
  181.         k=atoi(record[count].size);
  182.         k=k/1024;
  183.         if (k!=0)
  184.         {
  185.           sprintf(record[count].size, "%dk", k);
  186.         }
  187.         
  188.         if (!checkExcludes(record[count].filename))
  189.         {         
  190.           indx[count]=count;
  191.           count ++;
  192.         }
  193.       }
  194.     }    
  195.   }
  196.   fclose(handle);
  197.   return(count);
  198. } 
  199.   
  200.  
  201.  
  202. /***************************************************************************/
  203. /*  createAlphaList                                                        */
  204. /***************************************************************************/
  205. int createAlphaList(char *fname)
  206. {  
  207.   int swapped, speedup, loop, tmp;
  208.   FILE *handle;
  209.   char filename[MAX_FILENAME], buffer[256];
  210.  
  211.   
  212.   /* Sort the list */
  213.   swapped = TRUE;
  214.   speedup = 0;
  215.   while (swapped==TRUE)
  216.   {
  217.     swapped=0;
  218.     for (loop=0; loop<total_files-1-speedup; loop++)
  219.     {
  220.       if (strcasecmp(record[indx[loop]].filename, record[indx[loop+1]].filename) >0 )
  221.       {    
  222.       
  223.         tmp          = indx[loop];
  224.         indx[loop]   = indx[loop+1];
  225.         indx[loop+1] = tmp;
  226.         swapped=TRUE;
  227.       } 
  228.     }
  229.     speedup ++;
  230.   }
  231.   
  232.   
  233.   
  234.   
  235.   /* Write out the sorted list to the file */
  236.     sprintf(filename, "%s-alpha-list.html", fname);
  237. //  strcpy(filename, "alpha/htm");
  238.   
  239.   /* Make sure we can open the html file */
  240.   if ((handle=fopen(filename,"w"))==NULL)
  241.   {
  242.     printf("Unable to open file '%s'\n", filename);
  243.     return(-1); 
  244.   }
  245.   fclose(handle);
  246.   
  247.   
  248.   /* Create the header */
  249.   sprintf(buffer, "%s Index in Alphabetical order of filename", fname);
  250.   writeHTMLHeader(filename, buffer, buffer);
  251.   
  252.   
  253.   
  254.  
  255.  
  256. /*  for (loop=0; loop<count; loop++)
  257.   {
  258.     fprintf(handle, "%-40s %-10s %2s:%2s %2s %3s %4s  %s\n", 
  259.                        record[indx[loop]].filename, 
  260.                        record[indx[loop]].size, 
  261.                        record[indx[loop]].hour,
  262.                        record[indx[loop]].min,
  263.                        record[indx[loop]].daynum,
  264.                        record[indx[loop]].month,
  265.                        record[indx[loop]].year,
  266.                        record[indx[loop]].directory);
  267.   }
  268.   fclose(handle);
  269. */  
  270.   
  271.   
  272.  
  273.   
  274.   
  275.   /* Make sure we can open the html file */
  276.   if ((handle=fopen(filename,"a"))==NULL)
  277.   {
  278.     printf("Unable to open file '%s'\n", filename);
  279.     return(-1); 
  280.   }  
  281.   fprintf(handle, "<table border=0>\n");
  282.   
  283.   
  284.   
  285.   for (loop=0; loop<total_files; loop++)
  286.   {
  287.     sprintf(buffer, "%-25s", record[indx[loop]].filename);
  288.     buffer[20]='\0';
  289.     fprintf(handle, "<tr><td>%-25s<td align=right>%.9s<td>%2s:%2s %2s %3s %4s", 
  290.                     buffer,
  291.                     record[indx[loop]].size, 
  292.                     record[indx[loop]].hour,
  293.                     record[indx[loop]].min,
  294.                     record[indx[loop]].daynum,
  295.                     record[indx[loop]].month,
  296.                     record[indx[loop]].year);
  297.                     
  298.     sprintf(buffer, "%s/%s", 
  299.                     record[indx[loop]].directory, 
  300.                     record[indx[loop]].filename);
  301.     if (strlen(buffer)>27)
  302.       strcpy(buffer+27,"...\0");
  303.                     
  304.     fprintf(handle, "<td><a href=\"%s/%s\">%s</a>",                  
  305.                     record[indx[loop]].directory,
  306.                     record[indx[loop]].filename,
  307.                     buffer);
  308.                     
  309.     fprintf(handle,"\n");        
  310.   }
  311.   
  312.   fprintf(handle, "</table>\n");  
  313.   
  314.   fclose(handle);
  315.   
  316.   writeHTMLFooter(filename);
  317.   
  318.   
  319.   return(0);
  320. }
  321.  
  322.  
  323.  
  324. /***************************************************************************/
  325. /*  createAuthorList                                                       */
  326. /***************************************************************************/
  327. int createAuthorList(char *fname)
  328. {
  329.   char filename[MAX_FILENAME];
  330.   char buffer[256], olddir[256];
  331.   FILE *handle;
  332.   int loop;
  333.   
  334.  
  335.   sprintf(filename, "%s-author-list.html", fname);
  336. //  strcpy(filename, "author/htm");
  337.   
  338.   /* Make sure we can open the html file */
  339.   if ((handle=fopen(filename,"w"))==NULL)
  340.   {
  341.     printf("Unable to open file '%s'\n", filename);
  342.     return(-1); 
  343.   }
  344.   fclose(handle);
  345.   
  346.   
  347.   /* Create the header */
  348.   sprintf(buffer, "%s Index by Author", fname);
  349.   writeHTMLHeader(filename, buffer, buffer);
  350.   
  351.   
  352.   /* Make sure we can open the html file */
  353.   if ((handle=fopen(filename,"a"))==NULL)
  354.   {
  355.     printf("Unable to open file '%s'\n", filename);
  356.     return(-1); 
  357.   } 
  358.   
  359.  
  360.  
  361.   olddir[0]='\0';
  362.   fprintf(handle, "<ul>\n");
  363.   for (loop=0; loop<total_files; loop++)
  364.   {
  365.     if (strcmp(olddir, record[loop].directory) != 0)
  366.     {
  367.       /* new directory name */
  368.       if (loop>0)
  369.       {
  370.         fprintf(handle, "</ul>\n");
  371.         fprintf(handle, "</ul>\n");
  372.       }
  373.       fprintf(handle, "<ul>\n");
  374.       strcpy(olddir, record[loop].directory);
  375.       fprintf(handle, "<li>Directory: <a href=\"%s\">%s</a></li>\n",
  376. record[loop].directory, record[loop].directory); 
  377. fprintf(handle, "<ul>\n");
  378.     }
  379.     
  380.     
  381.     sprintf(buffer, "%-20s", record[indx[loop]].filename);
  382.     buffer[20]='\0';
  383.     fprintf(handle, "<li>%2s:%2s %2s %3s %4s", 
  384.                     record[loop].hour,
  385.                     record[loop].min,
  386.                     record[loop].daynum,
  387.                     record[loop].month,
  388.                     record[loop].year);
  389.                     
  390.     sprintf(buffer, "%s", record[loop].filename);
  391.     if (strlen(buffer)>27)
  392.       strcpy(buffer+27,"...\0");
  393.                     
  394.     fprintf(handle, "<a href=\"%s/%s\">%s</a>(%s)</li>",                  
  395.                     record[loop].directory,
  396.                     record[loop].filename,
  397.                     buffer,
  398.                     record[loop].size);
  399.                     
  400.     fprintf(handle,"\n");        
  401.   }
  402.   
  403.   fprintf(handle, "</ul>\n");  
  404.   fprintf(handle, "</ul>\n");
  405.   fclose(handle);
  406.   
  407.   writeHTMLFooter(filename);
  408.   
  409.   
  410.   return(0); 
  411. }
  412.  
  413.  
  414.  
  415. /***************************************************************************/
  416. /*  createLatestChanges                                                    */
  417. /***************************************************************************/
  418. int createLatestChanges(char *filename)
  419. {
  420.   return(0); 
  421. }
  422.  
  423.  
  424.  
  425. /***************************************************************************/
  426. /*  checkExcludes                                                          */
  427. /***************************************************************************/
  428. int checkExcludes(char *text)
  429. {
  430.   
  431.   int loop;
  432.   
  433.   for (loop=0; loop<total_excludes; loop++)
  434.   {
  435.     if (strstr(text, excludes[loop].filename)!=NULL)
  436.     {
  437. //      printf("%s", text);
  438.       return(TRUE); 
  439.     }
  440.   }
  441.     
  442.   return(FALSE); 
  443. }
  444.  
  445.  
  446.  
  447. /***************************************************************************/
  448. /*  readExcludes                                                           */
  449. /***************************************************************************/
  450. int readExcludes(void)
  451. {
  452.   FILE *handle;
  453.   char tmp[80];
  454.   int count=0;
  455.  
  456.  
  457.   if ((handle = fopen("excludes", "r"))==NULL)
  458.   {
  459.     return(FALSE); 
  460.   }
  461.   
  462.   count=0;
  463.   while (!feof(handle) & (count < MAX_EXCLUDES))
  464.   {
  465.     fgets(tmp, sizeof(tmp), handle);
  466.     if (strlen(tmp)>1)
  467.     {
  468.       tmp[strlen(tmp)-1]='\0';
  469.       strncpy(excludes[count].filename, tmp, sizeof(excludes[count].filename));
  470.       excludes[count].filename[MAX_FILENAME-1]='\0';
  471.       count++;
  472.     } 
  473.   }
  474.   count--;
  475.   total_excludes=count;
  476.  
  477.   fclose(handle);
  478.   return(TRUE);
  479. }
  480.  
  481.  
  482.  
  483. /***************************************************************************/
  484. /*  writeHTMLHeader                                                        */
  485. /***************************************************************************/
  486. int writeHTMLHeader(char *filename, char *title, char *header)
  487. {
  488.   FILE *handle;
  489.   
  490.   if ((handle=fopen(filename, "w")) == NULL)
  491.   {
  492.     printf("Unable to open file '%s' for writing\n", filename);
  493.     return(-1); 
  494.   }
  495.   
  496.   fprintf(handle, "<html><head><title>%s</title></head>\n", title);
  497.   fprintf(handle, "<body background=\"www/images/bg.gif\">\n");
  498.   fprintf(handle, "<h2 align=center>%s</h2>\n", header);
  499.   
  500.   fprintf(handle, "<p>This file is automatically generated each night by this <a href=\"www/list.c\">C source
  501. program.</a>\n");
  502.   fprintf(handle, "<hr>\n");
  503.   fclose(handle);
  504.   return(0);  
  505. }
  506.  
  507.  
  508.  
  509. /***************************************************************************/
  510. /*  wrtieHTMLFooter                                                        */
  511. /***************************************************************************/
  512. int writeHTMLFooter(char *filename)
  513. {
  514.   FILE *handle;
  515.   
  516.   if ((handle=fopen(filename, "a")) == NULL)
  517.   {
  518.     printf("Unable to open file '%s' for appending\n", filename);
  519.     return(-1); 
  520.   }
  521.   
  522.   
  523.   fprintf(handle, "<hr>\n");
  524. //  fprintf(handle, "<p>Automatically generated at %s</p>\n", d);
  525.   fprintf(handle, "<p><a href=\"mailto:ftpadmin@barnet.ac.uk\">ftpadmin@barnet.ac.uk</a></p>\n");
  526.   fprintf(handle, "</body></html>\n");
  527.   
  528.   fclose(handle);
  529.   
  530.   return(0); 
  531. }
  532.  
  533.  
  534.